/**
 * 文件上传和解析工具
 * 用于处理JSON文件的上传、解析和数据校验
 */

import { convertJsonToEchartsFormat, validateData } from './dataConverter.js';

/**
 * 校验JSON数据格式是否符合要求
 * @param {Object} jsonData - 需要校验的JSON数据
 * @returns {Object} 校验结果
 */
export const validateJsonFormat = (jsonData) => {
  const errors = [];
  const warnings = [];

  // 检查基本结构
  if (!jsonData || typeof jsonData !== 'object') {
    errors.push('数据必须是一个有效的JSON对象');
    return { isValid: false, errors, warnings, data: null };
  }

  // 检查series字段
  if (!jsonData.series) {
    errors.push('缺少必需的"series"字段');
    return { isValid: false, errors, warnings, data: null };
  }

  if (!Array.isArray(jsonData.series)) {
    errors.push('"series"字段必须是一个数组');
    return { isValid: false, errors, warnings, data: null };
  }

  if (jsonData.series.length === 0) {
    errors.push('"series"数组不能为空');
    return { isValid: false, errors, warnings, data: null };
  }

  // 检查标题格式（可选）
  if (jsonData.title) {
    if (typeof jsonData.title !== 'object') {
      errors.push('"title"字段必须是一个对象');
    } else if (!jsonData.title.text || typeof jsonData.title.text !== 'string') {
      errors.push('"title.text"字段必须是一个非空字符串');
    }
  }

  // 检查每个系列
  jsonData.series.forEach((series, seriesIndex) => {
    if (!series || typeof series !== 'object') {
      errors.push(`系列${seriesIndex + 1}必须是一个对象`);
      return;
    }
    // 检查系列名称
    if (!series.name || typeof series.name !== 'string') {
      warnings.push(`系列${seriesIndex + 1}缺少"name"字段或类型不正确，将使用默认名称`);
    }

    // 检查系列类型
    if (!series.type || typeof series.type !== 'string') {
      warnings.push(`系列${seriesIndex + 1}缺少"type"字段或类型不正确，将使用默认类型`);
    }

    // 检查数据字段
    if (!series.data) {
      errors.push(`系列${seriesIndex + 1}缺少必需的"data"字段`);
      return;
    }

    if (!Array.isArray(series.data)) {
      errors.push(`系列${seriesIndex + 1}的"data"字段必须是一个数组`);
      return;
    }

    if (series.data.length === 0) {
      warnings.push(`系列${seriesIndex + 1}的数据数组为空`);
      return;
    }

    // 检查每个数据点
    series.data.forEach((point, pointIndex) => {
      if (!point || typeof point !== 'object') {
        errors.push(`系列${seriesIndex + 1}的数据点${pointIndex + 1}必须是一个对象`);
        return;
      }

      // 检查x值 - 支持数字和字符串（分类轴）
      if (typeof point.x === 'undefined') {
        errors.push(`系列${seriesIndex + 1}的数据点${pointIndex + 1}缺少"x"字段`);
      } else if (typeof point.x === 'number') {
        // 如果是数字，检查是否有效
        if (!isFinite(point.x)) {
          errors.push(`系列${seriesIndex + 1}的数据点${pointIndex + 1}的"x"值必须是一个有效数字`);
        }
      } else if (typeof point.x === 'string') {
        // 如果是字符串，检查是否为空
        if (point.x.trim() === '') {
          errors.push(`系列${seriesIndex + 1}的数据点${pointIndex + 1}的"x"值不能为空字符串`);
        }
      } else {
        errors.push(`系列${seriesIndex + 1}的数据点${pointIndex + 1}的"x"值必须是数字或字符串`);
      }

      // 检查y值 - 必须是数字
      if (typeof point.y === 'undefined') {
        errors.push(`系列${seriesIndex + 1}的数据点${pointIndex + 1}缺少"y"字段`);
      } else if (typeof point.y !== 'number' || !isFinite(point.y)) {
        errors.push(`系列${seriesIndex + 1}的数据点${pointIndex + 1}的"y"值必须是一个有效数字`);
      }

      // 检查是否有多余的字段
      const allowedFields = ['x', 'y'];
      const extraFields = Object.keys(point).filter(key => !allowedFields.includes(key));
      if (extraFields.length > 0) {
        warnings.push(`系列${seriesIndex + 1}的数据点${pointIndex + 1}包含多余字段: ${extraFields.join(', ')}，这些字段将被忽略`);
      }
    });
  });

  // 检查是否至少有一个有效的数据系列
  const hasValidDataSeries = jsonData.series.some((series) => {
    // 检查是否有有效的数据
    return series.data && Array.isArray(series.data) && series.data.length > 0;
  });

  if (!hasValidDataSeries) {
    errors.push('必须至少包含一个有效的数据系列');
  }

  return {
    isValid: errors.length === 0,
    errors,
    warnings,
    data: jsonData
  };
};

/**
 * 读取文件内容
 * @param {File} file - 要读取的文件
 * @returns {Promise<string>} 文件内容
 */
export const readFileContent = (file) => {
  return new Promise((resolve, reject) => {
    if (!file) {
      reject(new Error('没有选择文件'));
      return;
    }

    // 检查文件类型
    if (!file.name.toLowerCase().endsWith('.json')) {
      reject(new Error('请选择JSON格式的文件'));
      return;
    }

    // 检查文件大小（限制为5MB）
    const maxSize = 5 * 1024 * 1024; // 5MB
    if (file.size > maxSize) {
      reject(new Error('文件大小不能超过5MB'));
      return;
    }

    const reader = new FileReader();
    
    reader.onload = (event) => {
      try {
        resolve(event.target.result);
      } catch (error) {
        reject(new Error('文件读取失败'));
      }
    };

    reader.onerror = () => {
      reject(new Error('文件读取出错'));
    };

    reader.readAsText(file, 'UTF-8');
  });
};

/**
 * 解析JSON字符串
 * @param {string} jsonString - JSON字符串
 * @returns {Object} 解析结果
 */
export const parseJsonString = (jsonString) => {
  try {
    if (!jsonString || typeof jsonString !== 'string') {
      throw new Error('无效的JSON字符串');
    }

    const jsonData = JSON.parse(jsonString);
    return {
      success: true,
      data: jsonData,
      error: null
    };
  } catch (error) {
    return {
      success: false,
      data: null,
      error: `JSON解析失败: ${error.message}`
    };
  }
};

/**
 * 完整的文件处理流程
 * @param {File} file - 上传的文件
 * @returns {Promise<Object>} 处理结果
 */
export const processJsonFile = async (file) => {
  try {
    // 1. 读取文件内容
    const fileContent = await readFileContent(file);
    
    // 2. 解析JSON
    const parseResult = parseJsonString(fileContent);
    if (!parseResult.success) {
      return {
        success: false,
        error: parseResult.error,
        data: null,
        validationResult: null
      };
    }

    // 3. 校验数据格式
    const validationResult = validateJsonFormat(parseResult.data);
    
    // 4. 如果校验通过，转换为ECharts格式
    let convertedData = null;
    if (validationResult.isValid) {
      try {
        convertedData = convertJsonToEchartsFormat(validationResult.data);
        
        // 5. 验证转换后的数据
        const isValidConverted = validateData(convertedData);
        if (!isValidConverted) {
          return {
            success: false,
            error: '数据转换后验证失败',
            data: null,
            validationResult
          };
        }
      } catch (error) {
        return {
          success: false,
          error: `数据转换失败: ${error.message}`,
          data: null,
          validationResult
        };
      }
    }

    return {
      success: validationResult.isValid,
      error: validationResult.errors.length > 0 ? validationResult.errors.join('; ') : null,
      data: convertedData,
      validationResult,
      originalData: parseResult.data
    };

  } catch (error) {
    return {
      success: false,
      error: error.message,
      data: null,
      validationResult: null
    };
  }
};

/**
 * 生成示例JSON文件内容
 * @returns {string} 示例JSON字符串
 */
export const generateExampleJson = () => {
  const exampleData = {
    "title": {
      "text": "标题测试数据"  
    },
    "series": [
      {
        "name": "系列1",
        "type": "line",
        "data": [
          { "x": "1月", "y": 55 },
          { "x": "2月", "y": 66 },
          { "x": "3月", "y": 68 },
          { "x": "4月", "y": 60 },
          { "x": "5月", "y": 69 },
          { "x": "6月", "y": 77 },
          { "x": "7月", "y": 70 },
          { "x": "8月", "y": 79 },
          { "x": "9月", "y": 81 }
        ]
      },
      {
        "name": "系列2",
        "type": "line",
        "data": [
          { "x": "1月", "y": 45 },
          { "x": "2月", "y": 56 },
          { "x": "3月", "y": 58 },
          { "x": "4月", "y": 50 },
          { "x": "5月", "y": 59 },
          { "x": "6月", "y": 67 },
          { "x": "7月", "y": 60 },
          { "x": "8月", "y": 69 },
          { "x": "9月", "y": 71 }
        ]
      },
      {
        "name": "系列3",
        "type": "bar",
        "data": [
          { "x": "1月", "y": 35 },
          { "x": "2月", "y": 46 },
          { "x": "3月", "y": 48 },
          { "x": "4月", "y": 40 },
          { "x": "5月", "y": 49 },
          { "x": "6月", "y": 57 },
          { "x": "7月", "y": 50 },
          { "x": "8月", "y": 59 },
          { "x": "9月", "y": 61 }
        ]
      }
    ],
    "生成时间": new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })
  };
  
  return JSON.stringify(exampleData, null, 2);
};

/**
 * 下载示例JSON文件
 */
export const downloadExampleJson = () => {
  const jsonContent = generateExampleJson();
  const blob = new Blob([jsonContent], { type: 'application/json' });
  const url = URL.createObjectURL(blob);
  
  const link = document.createElement('a');
  link.href = url;
  link.download = 'multi-series-example-new.json';
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  
  URL.revokeObjectURL(url);
}; 